home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1997 February / EnigmA AMIGA RUN 15 (1997)(G.R. Edizioni)(IT)[!][issue 1997-02][PLANET CD V].iso / enigma / earcd / comm / comm5 / nwsbrkr5.lha / Reader / NewsBreaker / src / ums / Handling.c < prev    next >
Text File  |  1996-12-16  |  15KB  |  684 lines
  1. /*
  2.  *   UMS-Handling
  3.  *
  4.  * SetAktMsgGroup -- User-Gruppenwunsch setzen
  5.  * FreeGroupList -- "Gruppen"-Liste löschen
  6.  * FreeMsgList -- Liste mit Nachrichtennummern löschen
  7.  *
  8.  * MakeGroupList -- lowlevel "Gruppen"-Liste erzeugen
  9.  * MakeMsgList -- lowlevel "Nachrichten"-Liste erzeugen
  10.  * IsGroupInGlobMsgList -- Tool
  11.  *
  12.  * SetGlobMsgNum -- setzt globale Variable GlobMsgNum
  13.  * GetGlobMsgNum -- holt globale Variable GlobMsgNum
  14.  * SetGlobMsgGroup -- setzt NAME der im RAM gelisteten globalen Gruppe
  15.  * SetGlobMsgList -- setzt neue LISTE, löscht alte
  16.  *
  17.  * GetGroupList -- gibt Zeiger auf Gruppenliste oder NULL zurück
  18.  * GetMsgList -- holt Liste aller Nachrichten aus <group>
  19.  *
  20.  * GetNewGroup -- (obsolet) richtet neue Gruppenliste ein
  21.  *
  22.  * ResetNBDisplay -- löscht GUI Anzeigen und interne Listen
  23.  */
  24.  
  25.  
  26. /*
  27.  * SetAktMsgGroup -- User-Gruppenwunsch setzen
  28.  */
  29.  
  30. STRPTR SetAktMsgGroup (STRPTR name)
  31. {
  32.   if (AktMsgGroup)
  33.     {
  34.       free (AktMsgGroup);
  35.       AktMsgGroup = NULL;
  36.     }
  37.  
  38.   AktMsgGroup = strdup (name);    // unabhängig machen!!!
  39.  
  40.   return (AktMsgGroup);
  41. }
  42.  
  43. STRPTR GetAktMsgGroup (void)
  44. {
  45.   if (AktMsgGroup)
  46.     {
  47.       return(AktMsgGroup);
  48.     }
  49.   else
  50.     {
  51.     return (NULL);
  52.     }
  53. }
  54.  
  55.  
  56.  
  57. /*
  58.  *   FreeGroupList -- "Gruppen"-Liste löschen
  59.  */
  60.  
  61. void
  62. FreeGroupList (void)
  63. {
  64.   if (GlobGroupList)
  65.     {
  66.       KillListEntries(gad_group);   /* GUI-Listviews leeren */
  67.       KillListEntries(gad_message);
  68.       FreeMyList (GlobGroupList); /* interne Liste löschen */
  69.  
  70.       GlobGroupList = NULL;
  71.     }
  72. }
  73.  
  74. /*
  75.  * FreeMsgList -- Liste mit Nachrichtennummern löschen
  76.  */
  77.  
  78. void
  79. FreeMsgList (void)
  80. {
  81.   if (GlobMsgList)
  82.     {
  83.       KillListEntries(gad_message); /* locken, löschen, unlocken */
  84.  
  85.       /* danach STRPTR löschen */
  86.       SetGlobMsgList (NULL);    /* Globale korrigieren */
  87.       SetGlobMsgGroup (NULL);    /* String löschen */
  88.     }
  89. }
  90.  
  91. /* todo: Fehlerbehandlung wg. Speichermangel, sonst Guru! / */
  92.  
  93. /*
  94.  * MakeGroupList -- "Gruppen"-Liste erzeugen
  95.  *
  96.  * Durchsucht Messagebase und erzeugt eine Liste verfügbarer Netgroups.
  97.  * todo: umssupport.library einbauen
  98.  *
  99.  * INPUTS:
  100.  *   account -- UMS-Handle
  101.  *   list    -- ein mit NewList() initialisierter Exec-Listheader
  102.  *
  103.  * RESULT:
  104.  *   TRUE --  List-Nodes wurden korrekt erzeugt.
  105.  *   FALSE -- Fehler, meistens Speichermangel. Unvollständige Liste ist
  106.  *            eventuell in *list vorhanden, Nodes müssen
  107.  *            von aufrufender Routine  gelöscht werden.
  108.  */
  109.  
  110. BOOL
  111. MakeGroupList (UMSUserAccount account, struct List *list)
  112. {
  113.   BOOL success = TRUE;        /* erfolgreich oder Fehler? */
  114.   STRPTR group = NULL;        /* Pointer to group name */
  115.   STRPTR buffer = NULL;        /* Stringbuffer */
  116.   UMSMsgNum num = 0;        /* Zwischenspeicher */
  117.   UMSMsgNum count = 0;        /* zählt alle Messages in *group */
  118.  
  119.   UMSSelectTags (account, UMSTAG_SelReadLocal, TRUE,
  120.          UMSTAG_SelWriteLocal, TRUE,
  121.          UMSTAG_SelSet, 0,
  122.          UMSTAG_SelUnset, (1L << 0),
  123.          TAG_DONE);
  124.  
  125.   /* Erste Gruppe: alle privaten Nachrichten */
  126.  
  127.   if (buffer = malloc (100))
  128.     {
  129.       group = strdup ("");
  130.       if (group)
  131.     {
  132.       /* Setze local bit 0 in allen Nachrichten OHNE ViewAccess */
  133.       /* Damit werden diese Nachrichten von der weiteren */
  134.       /* Bearbeitung ausgeschlossen. */
  135.  
  136.  
  137.       UMSSelectTags (account, UMSTAG_SelWriteLocal, TRUE,
  138.              UMSTAG_SelSet, (1L << 0),
  139.              UMSTAG_SelQuick, TRUE,
  140.              UMSTAG_SelMask, UMSUSTATF_ViewAccess,
  141.              UMSTAG_SelMatch, 0,
  142.              TAG_DONE);
  143.  
  144.       /* es könnten nun auch andere Nachrichten ausgeschlossen */
  145.       /* werden, z.B. alle bereits gelesenen: */
  146.       /*   UMSUSTATF_Old = TRUE */
  147.  
  148.       /* kludge */
  149.       if (GlobalFocus == NeueMsg)
  150.         {
  151.           count = UMSSelectTags (account,
  152.                      UMSTAG_SelWriteLocal, TRUE,
  153.                      UMSTAG_SelSet, (1L << 0),
  154.                      UMSTAG_SelQuick, TRUE,
  155.                      UMSTAG_SelMask, UMSUSTATF_Old,
  156.                      UMSTAG_SelMatch, UMSUSTATF_Old,
  157.                      TAG_DONE);
  158.         }
  159.  
  160.       /* Hier beginnt der Aufbau der Gruppenliste */
  161.       /* die Messagebase wird durchsucht und für jede gefundene */
  162.       /* Gruppe ein Node in der Liste "list" erzeugt. */
  163.  
  164.       for (;;)
  165.         {
  166.           /* Setze local bit 0 auf alle Nachrichten in group */
  167.           /* count liefert die Anzahl der gefundenen Messages in *group */
  168.  
  169.           count = UMSSelectTags (account, UMSTAG_SelWriteLocal, TRUE,
  170.                      UMSTAG_SelSet, (1L << 0),
  171.                      UMSTAG_SelQuick, TRUE,
  172.                      UMSTAG_WGroup, group,
  173.                      TAG_DONE);
  174.  
  175.           free (group);
  176.  
  177.           /* Hole Messagenummer ...                           */
  178.           /* Suche eine Message mit local bit 0 NICHT gesetzt */
  179.  
  180.           num = UMSSearchTags (account, UMSTAG_SearchLocal, TRUE,
  181.                    UMSTAG_SearchMask, (1L << 0),
  182.                    UMSTAG_SearchMatch, 0,
  183.                    UMSTAG_SearchQuick, TRUE,
  184.                    TAG_DONE);
  185.  
  186.           if (!num)
  187.         {
  188.           break;    // num == NULL, bedeutet Nachricht gibts nicht
  189.  
  190.         }
  191.  
  192.           else        // alles OK...
  193.  
  194.         {
  195.           /* Hole Gruppenmame group */
  196.  
  197.           if (!UMSReadMsgTags (account, UMSTAG_RMsgNum, num,
  198.                        UMSTAG_RGroup, &group,
  199.                        TAG_DONE))
  200.             {
  201.               CheckErr ();
  202.               success = FALSE;
  203.               break;
  204.             }
  205.           else
  206.             {
  207.               if (!(group = strdup (group)))
  208.             {
  209.               success = FALSE;
  210.               break;
  211.             }
  212.               else
  213.             {
  214.               /* Gruppennamen-Ausgabe in einen Exec-Listnode */
  215.  
  216. /*
  217.    sprintf(buffer,"%s", 
  218.    count,
  219.  
  220.    UMSSelectTags(account,
  221.    UMSTAG_SelQuick,      TRUE,
  222.    UMSTAG_WGroup,        group,
  223.    TAG_DONE),
  224.  
  225.    group);
  226.  
  227.  */
  228.  
  229.               success = AddName (list, group);    // Listeneintrag
  230.               /* KLUDGE, TODO */
  231.  
  232.               UMSFreeMsg (account, num);
  233.               if (!success)
  234.                 break;
  235.             }
  236.  
  237.             }        /* else */
  238.  
  239.         }
  240.  
  241.         }            /* for (;;) */
  242.  
  243.       if (success)
  244.         {
  245.           /* primitive Sortierroutine für Exec-Liste:           */
  246.           /* -- list   zeigt auf den zu sortierenden Listheader */
  247.           /* -- mycmp  ist Einsprungadresse einer Vergleichsfunktion */
  248.           listsort (list, mycmp);
  249.  
  250.           GetMyListNames (list, gad_group);    /* fülle BOOPSI Listview */
  251.  
  252.         }
  253.       else
  254.         {
  255.           /* überflüssig */
  256.           success = FALSE;
  257.         }
  258.  
  259.  
  260.     }            /* group */
  261.       else
  262.     {
  263.       success = FALSE;
  264.     }
  265.  
  266.       free (buffer);
  267.     }
  268.   else                // !buffer
  269.  
  270.     {
  271.       success = FALSE;
  272.     }
  273.  
  274.   if (!success)
  275.     ShowError ("FEHLER -- möglicherweise inkonsistente Gruppenliste \n");
  276.  
  277.   return (success);
  278. }
  279.  
  280. /*
  281.  * MakeMsgList -- erzeugt eine Liste mit Nachichtennummern
  282.  *
  283.  * Durchsucht Messagebase und erzeugt eine Msg-Liste
  284.  *
  285.  * Inhalt:
  286.  *       - Name-String für Gadtools-Listview
  287.  *       - UMS-MsgNr für UMS-Library
  288.  *
  289.  *
  290.  * INPUTS
  291.  * - account:  UMS-User-account
  292.  * - list:     ein initialisiter Exec-Listheader für Msg-Liste
  293.  * - group:    (STRPTR) Gruppe, für die Msg-Liste gebaut wird.
  294.  *             todo: template und Umssupport
  295.  * - Focus:    (LONG) Einschränkung auf bestimmte Messages. (kludge)
  296.  *
  297.  * todo: Hier könnte die umssupport.library benutzt werden!
  298.  * todo1: Dann sind userkonfigurierbare Listen möglich ("Templates")
  299.  * todo2: Parameter, besonders die Globals müssen weg! (GlobalFocus)
  300.  * siehe auch Textfile <Neue Datenstrukturen>
  301.  */
  302.  
  303. BOOL
  304. MakeMsgList (UMSUserAccount account, struct List * list, STRPTR group, LONG Focus)
  305. {
  306.   STRPTR buffer = NULL;
  307.   UMSMsgNum num = 0;
  308.   LONG myMaximumMsg = 0xffffff;    // wieviel Nachrichten höchstens selektiert?
  309.  
  310.   BOOL success = TRUE;
  311.   LONGBITS mySearchMatch = NULL;
  312.  
  313.   STRPTR msgFrom, msgSubject;    // diese Variablen werden eingelesen
  314.  
  315.   LONG *msgTextLen;
  316.   LONG SearchLast = 0;
  317.  
  318.  
  319.   /* Initialisierung: lösche alle Lokal bzw. Login-Flags */
  320.   UMSSelectTags (account, UMSTAG_SelReadLocal, TRUE,
  321.          UMSTAG_SelWriteLocal, TRUE,
  322.          UMSTAG_SelSet, 0,      /* kein Flag setzen */
  323.          UMSTAG_SelUnset, ~0,    /* alle Flags löschen (32bit!) */
  324.          TAG_DONE);
  325.  
  326. /* Focus bearbeiten */
  327.   switch (Focus)
  328.     {
  329.     case (AlleMsg):
  330.       {
  331.     mySearchMatch = (1L << 1);
  332.     break;
  333.       }
  334.  
  335.     case (NeueMsg):
  336.       {
  337.     mySearchMatch = (1L << 0) | (1L << 1);
  338.     break;
  339.       }
  340.  
  341.     default:            /* kludge , todo */
  342.       {
  343.     if (Focus >= 10)
  344.       {
  345.         mySearchMatch = (1L << 1);
  346.         myMaximumMsg = Focus;
  347.       }
  348.     else
  349.       ShowError ("Fehler\n");
  350.     break;
  351.       }
  352.     }                /* switch (Focus) */
  353.  
  354. #define UMSMASK_NEW_MESSAGES  UMSUSTATF_ViewAccess | UMSUSTATF_PostPoned | UMSUSTATF_Old
  355.  
  356.   if (buffer = malloc (150))
  357.     {
  358.       /* wähle aus: alle neuen Nachrichten: */
  359.       num = UMSSelectTags (account,
  360.                            UMSTAG_SelMask, UMSMASK_NEW_MESSAGES,
  361.                UMSTAG_SelMatch, UMSUSTATF_ViewAccess,
  362.                UMSTAG_SelWriteLocal, TRUE,
  363.                UMSTAG_SelSet, (1L << 0),
  364.                UMSTAG_SelUnset, 0,
  365.                TAG_DONE);
  366.  
  367.       /* wähle aus: alle Nachrichten mit gleicher <group> */
  368.       num = UMSSelectTags (account, UMSTAG_WGroup, group,
  369.                UMSTAG_SelWriteLocal, TRUE,
  370.                UMSTAG_SelQuick, TRUE,
  371.                UMSTAG_SelSet, (1L << 1),
  372.                UMSTAG_SelUnset, 0,
  373.                TAG_DONE);
  374.  
  375.       /* wähle aus: letzte 25 Nachrichten einer <group> */
  376.       if (Focus >= 10)
  377.     {
  378.       LONGBITS myNewSearchMatch = (1L << 2);    // temporär
  379.       LONG count = myMaximumMsg;
  380.  
  381.       num = 0x7fffffff;    /* LONG_MAX */
  382.  
  383.       do
  384.         {
  385.           num = UMSSearchTags (account,
  386.                    UMSTAG_SearchLocal, TRUE,
  387.                    UMSTAG_SearchMask, (1L << 1),    /* ALLE msg in group */
  388.                    UMSTAG_SearchMatch, (1L << 1),
  389.                    UMSTAG_SearchDirection, -1,    /* rückwärts */
  390.                    UMSTAG_SearchLast, num,    /* welche war schon */
  391.                    TAG_DONE);
  392.           if (num)
  393.         {
  394.           if (!UMSSelectTags (account,
  395.                       UMSTAG_SelMsg, num,
  396.                       UMSTAG_SelWriteLocal, TRUE,
  397.                       UMSTAG_SelSet, (1L << 2),
  398.                       UMSTAG_SelUnset, 0,
  399.                       TAG_DONE))
  400.             {
  401.               CheckErr ();
  402.             }
  403.  
  404.           count = count - 1;
  405.         }
  406.           else
  407.         {
  408.           CheckErr ();
  409.           count = 0;
  410.         }
  411.           printf ("Letzte25   num %ld, count %ld\n", num, count);
  412.         }
  413.       while (count);
  414.  
  415.       mySearchMatch = myNewSearchMatch;
  416.     }
  417.  
  418.       while (num)        // solange != Null
  419.     {
  420.       num = UMSSearchTags (account,
  421.                    UMSTAG_SearchLast, SearchLast,
  422.                    UMSTAG_SearchLocal, 0,
  423.                    UMSTAG_SearchMask, mySearchMatch,
  424.                    UMSTAG_SearchMatch, mySearchMatch,
  425.                    TAG_DONE);
  426.       if (num)
  427.         {
  428.           success = UMSReadMsgTags (account,
  429.                     UMSTAG_RMsgNum, num,
  430.                     UMSTAG_RFromName, &msgFrom,
  431.                     UMSTAG_RTextLength, &msgTextLen,
  432.                     UMSTAG_RSubject, &msgSubject,
  433.                     UMSTAG_RNoUpdate, 1L,
  434.                     TAG_DONE);
  435.  
  436.           if (success)
  437.         {
  438.                   BOOL result = TRUE;
  439.                   ULONG flen = NULL;
  440.  
  441.                   #define STRSIZE 20
  442.                   if ( strlen(msgFrom) > STRSIZE )
  443.                      {
  444.                      msgFrom[STRSIZE-1]='.';
  445.                      msgFrom[STRSIZE-2]='.';
  446.                      msgFrom[STRSIZE-3]='.';
  447.                      }
  448.  
  449.           sprintf (buffer, "%-20.20s %-.50s  (%ld)",
  450.                            msgFrom, msgSubject, msgTextLen);
  451.  
  452.           UMSFreeMsg (account, num);
  453.                   //printf("+");
  454.                   result = AddNameNum (list, buffer, num);
  455.                   //printf("o ");
  456.  
  457.           if (!result)
  458.                     {
  459.             ShowError ("UMS_Handling:\nFehler bei AddNameNum!");
  460.                     success = FALSE;
  461.                     }
  462.         }
  463.           else
  464.         {
  465.           CheckErr ();
  466.                   //printf("-  ");
  467.         }
  468.  
  469.           SearchLast = num;    // Nachricht (num) nicht mehr wählen
  470.         }
  471.  
  472.     }            //while
  473.  
  474.       free (buffer);
  475.     }
  476.   else
  477.     {
  478.     success = FALSE;
  479.     }
  480.  
  481.   if (list)
  482.   if (success)
  483.     {
  484.     //printf("\nUMSHandling: Starte Listsort (list, mycmp);\n");
  485.  
  486.     listsort (list, mycmp);
  487.  
  488.     //printf("\nUMSHandling: Starte GetMyListNames (list, gad_message);\n");
  489.  
  490.     GetMyListNames (list, gad_message);    /* fülle BOOPSI Listview */
  491.     }
  492.     else
  493.     {
  494.     ShowError("UMSHandling\nNicht gestartet: GetMyListNames");
  495.     }
  496.  
  497.   printf ("Ende MakeMsgList, %s", success ? "mit Erfolg!\n" : "ohne Erfolg.\n");
  498.   return (success);        // Dummy!!!
  499. }
  500.  
  501. /********************************************************************/
  502.  
  503. BOOL
  504. IsGroupInGlobMsgList (STRPTR group)
  505. {
  506. // group -- neu einzurichtende Liste für Gruppe <group>
  507. // GlobMsgGroup -- die möglicherweise schon (global) vorhandene Liste
  508.  
  509.   if (group)
  510.     if (strcmp (group, GlobMsgGroup) == 0)    // beide Strings gleich?
  511.  
  512.       {
  513.     return (TRUE);
  514.       }
  515.   return (FALSE);
  516. }
  517.  
  518. /*
  519.  * SetGlobMsgNum -- setzt globale Variable GlobMsgNum
  520.  *
  521.  *
  522.  */
  523.  
  524. void
  525. SetGlobMsgNum (UMSMsgNum myNum)
  526. {
  527.   /* Globale setzen (auf die jetzt angezeigte Message:)  */
  528.   GlobMsgNum = myNum;
  529. }
  530.  
  531. /*
  532.  * GetGlobMsgNum -- holt globale Variable GlobMsgNum
  533.  */
  534.  
  535. UMSMsgNum
  536. GetGlobMsgNum (void)
  537. {
  538.   /* Globale MessageNr holen  */
  539.   return (GlobMsgNum);
  540. }
  541.  
  542. /*
  543.  * SetGlobMsgGroup -- setzt Name der globalen Gruppe
  544.  */
  545.  
  546. void
  547. SetGlobMsgGroup (STRPTR group)
  548. {
  549.   if (GlobMsgGroup)
  550.     {
  551.       free (GlobMsgGroup);
  552.       GlobMsgGroup = NULL;    /* NULL = es gibt keine MsgListe */
  553.     }
  554.   if (group)
  555.     GlobMsgGroup = strdup (group);
  556. }
  557.  
  558. /*
  559.  * SetGlobMsgList -- setzt neue Liste, löscht alte
  560.  */
  561.  
  562. void
  563. SetGlobMsgList (List * list)
  564. {
  565.   if (GlobMsgList)
  566.     {
  567.       FreeMyList (GlobMsgList);
  568.       GlobMsgList = NULL;
  569.     }
  570.   GlobMsgList = list;
  571. }
  572.  
  573. /*-------------------------------------------------------------*/
  574.  
  575. /*
  576.  * GetGroupList -- gibt Zeiger auf Gruppenliste oder NULL zurück
  577.  */
  578.  
  579. struct List *
  580. GetGroupList (UMSUserAccount account)
  581. {
  582.   struct List *list = NULL;
  583.  
  584.   if (!GlobGroupList)
  585.     {
  586.       /* baue neue Gruppenliste */
  587.  
  588.       if (list = AllocMem (sizeof (struct List), MEMF_PUBLIC | MEMF_CLEAR))
  589.     {
  590.       NewList (list);    /* Init neuer Listheader */
  591.       MakeGroupList (account, list);    /* Einträge ... */
  592.       GlobGroupList = list;    /* Globaler Zeiger auf Listheader */
  593.     }
  594.       else
  595.     ShowError ("GetGroupList: Speicher für Liste fehlt!");
  596.     }
  597.   else
  598. /* verwende vorh. Gruppenliste */
  599.     {
  600.       list = GlobGroupList;    /* Globaler Zeiger auf Listheader */
  601.     }
  602.   return (list);
  603. }
  604.  
  605.  
  606. // todo: STRPTR group wird ein FILTERSTRING. (umssupport)
  607.  
  608. /*
  609.  * GetMsgList -- holt Liste aller Nachrichten aus <group>
  610.  *
  611.  */
  612.  
  613. struct List *
  614. GetMsgList (UMSUserAccount account, STRPTR group, LONG focus)
  615. {
  616.   struct List *list = NULL;
  617.   BOOL success = TRUE;
  618.  
  619.   if (!(IsGroupInGlobMsgList (group)))
  620.     {
  621.       if (list = AllocMem (sizeof (struct List), MEMF_PUBLIC | MEMF_CLEAR))
  622.     {
  623.       NewList (list);    // Init neuer Listheader
  624.       MakeMsgList (account, list, group, focus);
  625.  
  626.       SetGlobMsgList (list);    /* alte Liste falls vorh. löschen, neue Liste setzen */
  627.       SetGlobMsgGroup (group);
  628.     }
  629.       else
  630.     {
  631.       ShowError ("GetMsgList\nSpeicher ist voll!");
  632.       success = FALSE;
  633.     }
  634.     }
  635.   else
  636.     /* alte Liste verwenden */
  637.     {
  638.       list = GlobMsgList;
  639.     }
  640.  
  641.   return (list);
  642. }
  643.  
  644. /*
  645.  * GetNewGroup -- richte neue Gruppe ein
  646.  *
  647.  * INPUTS
  648.  * RESULT
  649.  *   TRUE  -- neue Gruppe wurde gewählt
  650.  *   FALSE -- keine neue Gruppe gewählt
  651.  */
  652.  
  653. /*
  654. BOOL
  655. GetNewGroup (UMSUserAccount account)
  656. {
  657.   UMSMsgNum num = 0;
  658.   struct List *list = NULL;
  659.   struct MyNodes *myNode = NULL;
  660.   BOOL success = TRUE;
  661.  
  662.   list = GetGroupList (account);
  663.   return (success);
  664. }
  665. */
  666.  
  667. /*
  668.  * ResetNBDisplay -- löscht GUI Anzeigen und interne Listen
  669.  * todo: zieht listview itemlist Gadgets den Boden unter den Füßen weg-
  670.  */
  671.  
  672. void
  673. ResetNBDisplay (void)
  674. {
  675.   /* todo: Gadgets löschen oder für ungültig erklären */
  676.   FreeMsgList ();        /* lösche die interne Message-Liste */
  677.   FreeGroupList ();        /* auch Gruppenliste löschen + GlobGroupName */
  678.  
  679.   /* Display löschen */
  680.   InfoBarClear (Mywindow, infobar_h);    /* todo: Fensterlöschfunktion */
  681.   DisplayTxt (txtfld, Mywindow, "<<Leeres Textfenster>>");
  682.   SetGlobMsgNum (0);
  683. }
  684.